home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Languages / PowerMacOberon 1.2 / Source / Tools / Strings.Mod (.txt) < prev    next >
Oberon Text  |  1995-08-22  |  4KB  |  117 lines
  1. Syntax10.Scn.Fnt
  2. FoldElems
  3. Syntax10.Scn.Fnt
  4. (*-------------------------------------------------------------
  5. Strings provides a set of operations on strings (i.e., on string constants and character
  6. arrays, both of which contain the character 0X as a terminator). All positions in
  7. strings start at 0. 
  8. Strings.Length(s)
  9.     returns the number of characters in s up to and excluding the first 0X.
  10. Strings.Insert(src, pos, dst)
  11.     inserts the string src into the string dst at position pos (0 <= pos <= Length(dst)).
  12.     If pos = Length(dst), src is appended to dst. If the size of dst is not large enough
  13.     to hold the result of the operation, the result is truncated so that dst is always
  14.     terminated with a 0X.
  15. Strings.Append(s, dst)
  16.     has the same effect as Insert(s, Length(s), dst). 
  17. Strings.Delete(s, pos, n)
  18.     deletes n characters from s starting at position pos (0 <= pos < Length(s)).
  19.     If n > Length(s) - pos, the new length of s is pos. 
  20. Strings.Replace(src, pos, dst)
  21.     has the same effect as Delete(dst, pos, Length(src)) followed by an Insert(src, pos, dst). 
  22. Strings.Extract(src, pos, n, dst)
  23.     extracts a substring dst with n characters from position pos (0 <= pos < Length(src)) in src.
  24.     If n > Length(src) - pos, dst is only the part of src from pos to Length(src) - 1. If the size of
  25.     dst is not large enough to hold the result of the operation, the result is truncated so that
  26.     dst is always terminated with a 0X. 
  27. Strings.Pos(pat, s, pos)
  28.     returns the position of the first occurrence of pat in s after position pos (inclusive).
  29.     If pat is not found, -1 is returned. 
  30. Strings.Cap(s)
  31.     replaces each lower case letter in s by its upper case equivalent.
  32. -------------------------------------------------------------*)
  33. Syntax10i.Scn.Fnt
  34. StampElems
  35. Alloc
  36. 1 Jun 95
  37. Syntax10b.Scn.Fnt
  38. Documentation
  39. MODULE Strings;    (*HM 94-06-22 / 
  40. PROCEDURE Length* (s: ARRAY OF CHAR): INTEGER;
  41.     VAR i: INTEGER;
  42. BEGIN
  43.     i := 0; WHILE (i < LEN(s)) & (s[i] # 0X) DO INC(i) END;
  44.     RETURN i
  45. END Length;
  46. PROCEDURE Append* (extra: ARRAY OF CHAR; VAR dest: ARRAY OF CHAR);
  47.     VAR n1, n2, i: INTEGER;
  48. BEGIN
  49.     n1 := Length(dest); n2 := Length(extra); i := 0;
  50.     WHILE (i < n2) & (i + n1 < LEN(dest)) DO dest[i + n1] := extra[i]; INC(i) END;
  51.     IF i + n1 < LEN(dest) THEN dest[i + n1] := 0X END
  52. END Append;
  53. PROCEDURE Insert* (source: ARRAY OF CHAR; pos: INTEGER; VAR dest: ARRAY OF CHAR);
  54.     VAR n1, n2, i: INTEGER;
  55. BEGIN
  56.     n1 := Length(dest); n2 := Length(source); 
  57.     IF pos < 0 THEN pos := 0 END;
  58.     IF pos > n1 THEN Append(dest, source); RETURN END;
  59.     IF pos + n2 < LEN(dest) THEN  (*make room for source*)
  60.         i := n1; (*move also 0X if it is there*)
  61.         WHILE i >= pos DO
  62.             IF i + n2 < LEN(dest) THEN dest[i + n2] := dest[i] END;
  63.             DEC(i)
  64.         END
  65.     END;
  66.     i := 0; WHILE i < n2 DO dest[pos + i] := source[i]; INC(i) END
  67. END Insert;
  68. PROCEDURE Delete* (VAR s: ARRAY OF CHAR; pos, n: INTEGER);
  69.     VAR len, i: INTEGER;
  70. BEGIN
  71.     len:=Length(s);
  72.     IF pos < 0 THEN pos:=0 ELSIF pos >= len THEN RETURN END;
  73.     IF pos + n < len THEN
  74.         i:=pos + n; WHILE i < len DO s[i - n]:=s[i]; INC(i) END;
  75.         IF i - n < LEN(s) THEN s[i - n]:=0X END
  76.     ELSE s[pos]:=0X
  77. END Delete;
  78. PROCEDURE Replace* (source: ARRAY OF CHAR; pos: INTEGER; VAR dest: ARRAY OF CHAR);
  79. BEGIN
  80.     Delete(dest, pos, pos + Length(source));
  81.     Insert(source, pos, dest)
  82. END Replace;
  83. PROCEDURE Extract* (source: ARRAY OF CHAR; pos, n: INTEGER; VAR dest: ARRAY OF CHAR);
  84.     VAR len, destLen, i: INTEGER;
  85. BEGIN
  86.     len := Length(source); destLen := SHORT(LEN(dest)) - 1;
  87.     IF pos < 0 THEN pos := 0 END;
  88.     IF pos >= len THEN dest[0] := 0X; RETURN END;
  89.     i := 0;
  90.     WHILE (pos + i <= LEN(source)) & (source[pos + i] # 0X) & (i < n) DO
  91.         IF i < destLen THEN dest[i] := source[pos + i] END;
  92.         INC(i)
  93.     END;
  94.     dest[i] := 0X
  95. END Extract;
  96. PROCEDURE Pos* (pattern, s: ARRAY OF CHAR; pos: INTEGER): INTEGER;
  97.     VAR n1, n2, i, j: INTEGER;
  98. BEGIN
  99.     n1 := Length(s); n2 := Length(pattern);
  100.     IF n2 = 0 THEN RETURN 0 END;
  101.     i := pos;
  102.     WHILE i <= n1 - n2 DO
  103.         IF s[i] = pattern[0] THEN
  104.             j := 1; WHILE (j < n2) & (s[i + j] = pattern[j]) DO INC(j) END;
  105.             IF j = n2 THEN RETURN i END
  106.         END;
  107.         INC(i)
  108.     END;
  109.     RETURN -1
  110. END Pos;
  111. PROCEDURE Cap* (VAR s: ARRAY OF CHAR);
  112.     VAR i: INTEGER;
  113. BEGIN
  114.     FOR i := 0 TO Length(s)-1 DO s[i] := CAP(s[i]) END
  115. END Cap;
  116. END Strings.
  117.